package com.ns.school.common.utils;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 通用工具类
 *
 * @author Spark
 */
public class JsonUtil {

    /**
     * 将json格式的字符串{"name":"admin","retries":"3fff"} 解析成Map对象
     *
     * @param str
     * @return
     */
    public static Map<String, String> jsonToMap(String str) {
        if (StrUtil.isEmpty(str)) {
            return null;
        }
        Map<String, String> data = new HashMap<>();
        JSONObject json = JSON.parseObject(str);
        Set<String> it = json.keySet();
        for (Object key : it) {
            data.put(key.toString(), json.getString(key.toString()));
        }
        return data;
    }

    /**
     * 将json对象解析成Map对象
     *
     * @param json
     * @return
     */
    public static Map<String, String> jsonToMap(JSONObject json) {
        Map<String, String> data = new HashMap<>();
        Set<String> it = json.keySet();
        for (String key : it) {
            data.put(key, json.getString(key));
        }
        return data;
    }

    /**
     * 将json 字符串 解析成Map对象
     *
     * @param str
     * @return
     */
    public static Map<?, ?> jsonToMapObj(String str) {
        return JSON.parseObject(str);
    }

    /**
     * 将json 字符串 解析成Map对象
     *
     * @param json
     * @return
     */
    public static <T> Map<String, T> toMapStrObject(String json, Class<T> clazz) {
        if (StrUtil.isEmpty(json)) {
            return null;
        }
        Map<String, T> data = new HashMap<>();
        JSONObject jsonObject = JSON.parseObject(json);
        Set<String> it = jsonObject.keySet();
        for (String key : it) {
            data.put(key, jsonObject.getObject(key, clazz));
        }
        return data;
    }

    /**
     * 将json 字符串 解析成Map对象
     *
     * @param json
     * @return
     */
    public static <T> Map<Integer, T> toMapIntObject(String json, Class<T> clazz) {
        if (StrUtil.isEmpty(json)) {
            return null;
        }
        Map<Integer, T> data = new HashMap<>();
        JSONObject jsonObject = JSON.parseObject(json);
        Set<String> it = jsonObject.keySet();
        for (String key : it) {
            data.put(Integer.parseInt(key), jsonObject.getObject(key, clazz));
        }
        return data;
    }

    /**
     * 将json 字符串 解析成Map对象
     *
     * @param json
     * @param clazz
     * @return
     */
    public static <T> Map<Long, T> toMapLongObject(String json, Class<T> clazz) {
        if (StrUtil.isEmpty(json)) {
            return null;
        }
        Map<Long, T> data = new HashMap<>();
        JSONObject jsonObject = JSON.parseObject(json);
        Set<String> it = jsonObject.keySet();
        for (String key : it) {
            data.put(Long.parseLong(key), jsonObject.getObject(key, clazz));
        }
        return data;
    }

    /**
     * 将java 对象 解析成JSONObject对象
     *
     * @param obj
     * @return
     */
    public static <T> JSONObject toJSONObject(T obj) {
        return JSON.parseObject(toStr(obj));
    }

    /**
     * json字符串转json对象
     *
     * @param json
     * @return T
     */
    public static JSONObject toJSONObject(String json) {
        return JSON.parseObject(json);
    }

    /**
     * 将java对象 解析成JSONArray对象
     *
     * @param obj
     * @return
     */
    public static <T> JSONArray toJSONArray(T obj) {
        return JSON.parseArray(toStr(obj));
    }

    /**
     * java对象转json字符
     *
     * @param o
     * @return String
     */
    public static <T> String toStr(T o) {
        return JSON.toJSONString(o);
    }

    /**
     * json转java对象
     *
     * @param json
     * @param clazz
     * @return T
     */
    public static <T> T toJavaObject(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }

    /**
     * json转java对象
     *
     * @param json
     * @param clazz
     * @return T
     */
    public static <T> T toJavaObject(JSONObject json, Class<T> clazz) {
        return json.toJavaObject(clazz);
    }

    /**
     * json转java集合
     *
     * @param json
     * @param clazz
     * @return T
     */
    public static <T> List<T> toList(String json, Class<T> clazz) {
        return JSON.parseArray(json, clazz);
    }

    /**
     * json转java集合
     *
     * @param json
     * @param clazz
     * @return T
     */
    public static <T> List<T> toList(JSONArray json, Class<T> clazz) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        return json.toJavaList(clazz);
    }

}
